Computer-enabled graphical editing systems are used in a wide variety of different applications and industries to view and edit different types of visual images on computer systems or other electronic devices. One common application is electronic design automation, including such applications as schematic design and layout design, in which the designs for components and spatial layout of electronic components such as integrated circuits and circuit boards are viewed, created and edited using displayed images.
Circuit designers use graphical display software to display, navigate, create and edit circuit schematics and layout designs. Since integrated circuit designs, and other types of designs, can be extremely large and complex, these designs are often decomposed into different hierarchical levels. Hierarchical decomposition has long been an aid in allowing a high level of complexity to be attained in designs. The highest level of the hierarchy may show an overall simplified view of the design including abstracted symbols or other markers representing more complex components of the design. To view details of a symbol, the hierarchy can be descended to the next level on that desired symbol, which may include components allowing a further descent to a lower level of the hierarchy, and so on.
Hierarchical decomposition, however, often leads to burdensome navigation operations for designers. Breaking designs into hierarchies comes at a cost of requiring users to later navigate those hierarchies when debugging designs or physically implementing designs in layout. For example, schematic hierarchy navigation operations have been found to occur almost as frequently as zoom and select operations.
Some graphical application software has included navigation selection features to support navigation of design hierarchical levels in general. For example, in an existing design application, a list of text labels is displayed in a separate window. The user can select any of the text labels to navigate to the corresponding cell, module, or hierarchical level. The software also displays a “Go” toolbar, which when selected displays a navigation history of cells or modules which have been previously displayed, from which the user can select to navigate to the selected cell or module.
However, these types of features can be awkward for users. One reason is that these functions require the user to move his or her attention, and the controlled cursor, away from the schematic canvas. This directs the user focus away from the canvas and creates delays in returning focus back to the canvas and the objects to viewed or edited. In addition, these functions identify different views or levels in a textual format. A user must read and parse these text names or hierarchical occurrence paths in order to determine which module or cell is which. For example, a list of design cells in an integrated circuit layout can be displayed, but design cells are often stored in the same library, and sub-cells are often given similar names to the parent cells which instantiate them. A user attempting to manually read and parse these path names will have a lot of reading and scanning from left to right in order to extract the most pertinent piece of information (which often appears at the end or right side of a text identifier, many characters into the text string). The user then has to recall and recognize those text strings and associate them with particular design cells, which is cumbersome. Further, designers often employ variants of any given design cell, and analog designers in particular often employ variants which are topologically quite different from one another. Such variants are not easily recognizable in the existing navigation selection features.
Graphical applications also typically include standard zoom and pan operations to allow a user to navigate within a design canvas to get to different levels of the design. However, this is awkward as well. For example, the higher-level schematic design symbols are often simple rectangles in shape, and it is often the case that a user has to substantially alter the zoom level in order to obtain additional information to determine if a given symbol instance is truly the one into which he wishes to descend. (Greater zoom magnification will cause a symbol to be displayed larger, but will not reveal the details of any lower level of the hierarchy.) Thus, the user may try to have the schematic drawn at a sufficiently low zoom level in order to make the text labels on the instances fully visible such that they can be read (and again mentally parsed), which often requires several zoom operations. Simultaneously, the user tries to combine the textual name with the symbol shape and layout to mentally associate the text labels with the desired underlying lower-level schematic diagram (which in practice is often quite different from the higher-level symbol shape).
Another issue is that such zoom, select, read, parse, and descend operations are often performed multiple times, particularly in schematics with multiple levels of hierarchy. For example, four or five levels deep is not uncommon, and in enormous designs (such as FPGAs) the number of hierarchical levels may easily exceed this. Users often navigate across several levels of hierarchy, e.g. when tracing a power net or the drivers or loads of a given signal, etc., thus repeating these operations many times. Some applications allow a user to probe signals. For example, one commercially available standalone graphical waveform viewer and netlist tracer allows a user to trace a given signal backwards or forwards along its fan-in/fan-out, listing text such a signal's name and driver/receiver, and allowing a user to select a driver or receiver to navigate to that main view and also synthesizing a schematic showing the signal of interest as it crosses hierarchical boundaries. However, programs such as this operate only in a textual manner, do not help the user visualize the hierarchical context of the signal connections, and do not leverage any existing schematic for schematic-based designs. Thus the existing features of graphical applications are inefficient and time-consuming when navigating multiple hierarchical levels of a design.